/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package pokerlan;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

/**
 *
 * @author Administrador
 */
public class mecanicaJuego {
    public static Jugador[] mesa = new Jugador[9];
    public static int boton;
    public static int posicionApuesta;
    public static int posicionApuestaOriginal;
    public static InputStreamReader isr = new InputStreamReader(System.in);
    public static BufferedReader lecturaTeclado = new BufferedReader (isr);
    public static GrupoApuesta[] Apuestas = new GrupoApuesta[9];
    public static int numeroGrupoApuestas;
    public static Carta[] cartasMesa = new Carta[5];


    /**
     * Agrega un jugador a la partida. Comprueba si en la posición en la que se
     * va a sentar el jugador hay otro jugador previamente.
     * @param player Jugador.
     * @param posicion Posicion en la que se sienta.
     * @return true si se añade correctamente y false si no se añade correctamente.
     */
    public static boolean newPlayer(Jugador player, int posicion){
        if(mesa[posicion] == null){
            mesa[posicion] = player;
            //System.out.println("Jugador añadido correctamente.");
            return true;
        }
        else{
            System.out.println("En esa posición ya hay un jugador");
            return false;
        }

    }

    /**
     * Esto únicamente se hace al inicio de la partida. Se decide aleatoriamente
     * quien será el botón.
     * @return La posición del botón.
     */
    public static void repartirBoton(){
        boolean encontrado = false;
        int posicion = 0;
        while(encontrado == false){
            posicion = (int)(Math.random()*9);
            if(mesa[posicion] != null)
                encontrado = true;
        }
        mecanicaJuego.boton = posicion;
    }

    /**
     * Gira el boton en el sentido de las agujas del reloj.
     */
    public static void moverBoton(){
        do{
            if(boton == 8)
                boton = 0;
            else
                boton++;
        }while(mesa[boton] != null && mesa[boton].mostrarFichas()>0);
    }

    /**
     *
     * Este método representa la acción de un jugador de hacer una apuesta.
     * @param player Jugador que hace la apuesta.
     * @throws IOException
     */
    public static void apostar(Jugador player) throws IOException{


        int fichasRestantes = player.mostrarFichas();
        int apostado = Apuestas[numeroGrupoApuestas].tablaApuesta[1][posicionApuesta];
        int apuestaAlta = Apuestas[numeroGrupoApuestas].apuestaAlta;
        int estadoJugador = Apuestas[numeroGrupoApuestas].tablaApuesta[0][posicionApuesta];
        int apuesta;

        switch(estadoJugador){
            case 1:
                /* Este caso se da cuando el jugador debe igualar una apuesta más alta que la suya para seguir jugando.
                 * Comprueba si la suma de las fichas que le quedan al jugador más las que ha apostado es inferior a lo
                 * que debe igualar. Si es así se le da la opción de apostar todo lo restante (All-In) o plantarse.
                 */
                if(apuestaAlta >= (fichasRestantes + apostado)){
                    System.out.println("Apuesta en la mesa: " +apuestaAlta);
                    System.out.println("Tienes estas fichas: " +fichasRestantes);
                    System.out.println("Para igualar te hace falta: " +(apuestaAlta-apostado));
                    System.out.println("Introduce 'a' para All-In(" +fichasRestantes +") o cualquier otra tecla para no ir y plantarte: ");
                    /* Si introduce 'a' se realiza el All-In */
                    if(lecturaTeclado.readLine().equalsIgnoreCase("a")){
                        player.sacarFichas(fichasRestantes);
                        Apuestas[numeroGrupoApuestas].introducirApuesta(posicionApuesta, 3, fichasRestantes);
                        System.out.println("Vas con todo");
                    }
                    else{
                        System.out.println("Te has plantado");
                        Apuestas[numeroGrupoApuestas].tablaApuesta[0][posicionApuesta] = 0;
                        player.plantarse();
                    }

                }
                else{
                    System.out.println("Apuesta en la mesa: " +apuestaAlta);
                    System.out.println("Tienes estas fichas: " +fichasRestantes);
                    System.out.println("Para igualar te hace falta: " +(apuestaAlta-apostado));
                    System.out.println("Introduce 'a' para All-In(" +fichasRestantes +"), 'i' para igualar la apuesta, 's' para subir o cualquier otra tecla para no ir: ");
                    switch(lecturaTeclado.readLine().charAt(0)){
                        case 'a':
                            player.sacarFichas(fichasRestantes);
                            Apuestas[numeroGrupoApuestas].introducirApuesta(posicionApuesta, 3, fichasRestantes);
                            System.out.println("Vas con todo");
                            break;
                        case 'i':
                            player.sacarFichas(apuestaAlta-apostado);
                            Apuestas[numeroGrupoApuestas].introducirApuesta(posicionApuesta, 2, apuestaAlta-apostado);
                            System.out.println("Has igualado");
                            break;
                        case 's':
                            System.out.println("Introduce la cantidad de fichas que vas a apostar: ");
                            apuesta = Integer.parseInt(lecturaTeclado.readLine());
                            if(apuesta > apuestaAlta){
                                if(apuesta < fichasRestantes){
                                    player.sacarFichas(apuesta);
                                    Apuestas[numeroGrupoApuestas].introducirApuesta(posicionApuesta, 2, apuesta);
                                    System.out.println("Has subido");
                                }
                                else{
                                    player.sacarFichas(fichasRestantes);
                                    Apuestas[numeroGrupoApuestas].introducirApuesta(posicionApuesta, 3, fichasRestantes);
                                    System.out.println("Vas con todo");
                                }
                            }
                            /* Si se introduce un valor menor del minimo para igualar, iguala automaticamente */
                            else{
                                player.sacarFichas(apuestaAlta-apostado);
                                Apuestas[numeroGrupoApuestas].introducirApuesta(posicionApuesta, 2, apuestaAlta - apostado);
                                System.out.println("Has igualado");
                            }
                            break;
                        default:
                            System.out.println("Te has plantado");
                            Apuestas[numeroGrupoApuestas].tablaApuesta[0][posicionApuesta] = 0;
                            player.plantarse();
                            break;
                    }
                }
                break;

            case 2:
                /* Este caso se da cuando el jugador tiene la puesta igualada y puede pasar, subir o hacer All-In */
                System.out.println("Apuesta en la mesa: " +apuestaAlta);
                System.out.println("Tienes estas fichas: " +fichasRestantes);
                System.out.println("Introduce 'a' para All-In(" +fichasRestantes +"), 's' para subir o cualquier otra tecla para pasar: ");
                switch(lecturaTeclado.readLine().charAt(0)){
                    case 'a':
                        player.sacarFichas(fichasRestantes);
                        Apuestas[numeroGrupoApuestas].introducirApuesta(posicionApuesta, 3, fichasRestantes);
                        System.out.println("Vas con todo");
                        break;
                    case 's':
                        System.out.println("Introduce la cantidad de fichas que vas a apostar: ");
                        apuesta = Integer.parseInt(lecturaTeclado.readLine());
                        if(apuesta > apuestaAlta){
                            if(apuesta < fichasRestantes){
                                player.sacarFichas(apuesta);
                                Apuestas[numeroGrupoApuestas].introducirApuesta(posicionApuesta, 2, apuesta);
                                System.out.println("Has subido");
                            }
                            else{
                                player.sacarFichas(fichasRestantes);
                                Apuestas[numeroGrupoApuestas].introducirApuesta(posicionApuesta, 3, fichasRestantes);
                                System.out.println("Vas con todo");
                            }
                        }
                        /* Si se introduce un valor menor del minimo para igualar, iguala automaticamente */
                        else{
                            player.sacarFichas(apuestaAlta-apostado);
                            Apuestas[numeroGrupoApuestas].introducirApuesta(posicionApuesta, 2, apuestaAlta - apostado);
                            System.out.println("Has igualado");
                        }
                        break;
                    default:
                        System.out.println("Has pasado");
                        break;
                }

            case 4:
                /* Este caso se da cuando el jugador tiene la puesta igualada y puede pasar, subir o hacer All-In */
                System.out.println("Apuesta en la mesa: " +apuestaAlta);
                System.out.println("Tienes estas fichas: " +fichasRestantes);
                System.out.println("Introduce 'a' para All-In(" +fichasRestantes +"), 's' para subir o cualquier otra tecla para pasar: ");
                switch(lecturaTeclado.readLine().charAt(0)){
                    case 'a':
                        player.sacarFichas(fichasRestantes);
                        Apuestas[numeroGrupoApuestas].introducirApuesta(posicionApuesta, 3, fichasRestantes);
                        System.out.println("Vas con todo");
                        break;
                    case 's':
                        System.out.println("Introduce la cantidad de fichas que vas a apostar: ");
                        apuesta = Integer.parseInt(lecturaTeclado.readLine());
                        if(apuesta > apuestaAlta){
                            if(apuesta < fichasRestantes){
                                player.sacarFichas(apuesta);
                                Apuestas[numeroGrupoApuestas].introducirApuesta(posicionApuesta, 2, apuesta);
                                System.out.println("Has subido");
                            }
                            else{
                                player.sacarFichas(fichasRestantes);
                                Apuestas[numeroGrupoApuestas].introducirApuesta(posicionApuesta, 3, fichasRestantes);
                                System.out.println("Vas con todo");
                            }
                        }
                        /* Si se introduce un valor menor del minimo para igualar, iguala automaticamente */
                        else{
                            player.sacarFichas(apuestaAlta-apostado);
                            Apuestas[numeroGrupoApuestas].introducirApuesta(posicionApuesta, 2, apuestaAlta - apostado);
                            System.out.println("Has igualado");
                        }
                        break;
                    default:
                        System.out.println("Has pasado");
                        break;
                }


        }
    }


    public static void moverPosicionApuesta(){
        boolean salir = false;
        while(salir == false){
            if(posicionApuesta == 8)
                posicionApuesta = 0;
            else
                posicionApuesta++;
            if(mesa[posicionApuesta] != null){
                if((mesa[posicionApuesta].mostrarFichas()>0) && (Apuestas[numeroGrupoApuestas].tablaApuesta[0][posicionApuesta] != 0))
                    salir = true;
            }
        }
    }

    /**
     * Este método se encarga de poner todos los jugadores que tienen fichas en estado "jugando".
     */
    public static void reiniciarEstados(){
        for(int i=0; i<9; i++){
            if(mesa[i]!=null && mesa[i].mostrarFichas()!=0)
                mesa[i].plantarse();
        }
    }

    /**
     * Esta es la primera fase del juego. Se le reparte 2 cartas a cada jugador
     * y viendo sus cartas deciden si igualar las apuestas ciegas, retirarse o subir.
     * Las apuestas ciegas son obligatorias (ciega pequeña y ciega grande) y las
     * tienen que poner los dos jugadores que están a las izquierda del jugador
     * que tiene el botón. El botón gira a la izquierda cada vez que se inicia una
     * nueva mano. La ciega pequeña se establece, y la ciega grande es el doble
     * que la ciega pequeña.
     * @param ciegaPequeña
     * @throws IOException
     */
    public static void preFlop(int ciegaPequeña) throws IOException{

        // Se barajan las cartas
        Carta.barajarCartas();

        // Se reinician los estados
        reiniciarEstados();

        // Borra las apuestas anteriores que haya y se crea una nueva
        numeroGrupoApuestas = 0;
        Apuestas[0] = new GrupoApuesta();

        // Se reparten las cartas a cada jugador
        for(int i=0; i<9; i++){
            if(mesa[i] != null && mesa[i].mostrarFichas() > 0){
                mesa[i].nuevaMano(Carta.repartirCarta(), Carta.repartirCarta());
            }
        }

        // Se ponen la ciega pequeña y la ciega grande
        posicionApuesta = boton;
        moverPosicionApuesta();
        System.out.println("\n---- PRE-FLOP ----");
        System.out.println(mesa[posicionApuesta].mostrarNombre() +" pone la ciega pequeña");
        if(mesa[posicionApuesta].mostrarFichas() < ciegaPequeña){
            Apuestas[numeroGrupoApuestas].tablaApuesta[0][posicionApuesta] = 3;
            Apuestas[numeroGrupoApuestas].introducirApuesta(posicionApuesta, 3, mesa[posicionApuesta].mostrarFichas());
            mesa[posicionApuesta].sacarFichas(mesa[posicionApuesta].mostrarFichas());
            System.out.println("Vas con todo");
            posicionApuestaOriginal = posicionApuesta;
        }
        else{
            Apuestas[numeroGrupoApuestas].tablaApuesta[0][posicionApuesta] = 2;
            Apuestas[numeroGrupoApuestas].introducirApuesta(posicionApuesta, Apuestas[numeroGrupoApuestas].tablaApuesta[0][posicionApuesta], ciegaPequeña);
            mesa[posicionApuesta].sacarFichas(ciegaPequeña);
        }
        // Se indica donde se ha iniciado la apuesta más grande, para saber hasta cuando hay que seguir apostando.
        posicionApuestaOriginal = posicionApuesta;

        moverPosicionApuesta();
        System.out.println(mesa[posicionApuesta].mostrarNombre() +" pone la ciega grande");
        if(mesa[posicionApuesta].mostrarFichas() < (ciegaPequeña*2)){
            Apuestas[numeroGrupoApuestas].tablaApuesta[0][posicionApuesta] = 3;
            Apuestas[numeroGrupoApuestas].introducirApuesta(posicionApuesta, 3, mesa[posicionApuesta].mostrarFichas());
            mesa[posicionApuesta].sacarFichas(mesa[posicionApuesta].mostrarFichas());
            System.out.println("Vas con todo");
        }
        else{
            Apuestas[numeroGrupoApuestas].tablaApuesta[0][posicionApuesta] = 2;
            Apuestas[numeroGrupoApuestas].introducirApuesta(posicionApuesta, 2, ciegaPequeña*2);
            mesa[posicionApuesta].sacarFichas(ciegaPequeña*2);
        }
        // Se comprueba si la apuesta actual supera a la que estaba establecida como la más grande. Si es así se asigna a la apuesta más grande.
        if((Apuestas[numeroGrupoApuestas].tablaApuesta[1][posicionApuesta]) > (Apuestas[numeroGrupoApuestas].tablaApuesta[1][posicionApuestaOriginal]))
            posicionApuestaOriginal = posicionApuesta;

        // Se realizan las apuestas mientras la comprobacion indique que no se ha terminado
        while((Apuestas[numeroGrupoApuestas].comprobarEstados() == false) && (GrupoApuesta.contarJugadores(Apuestas[numeroGrupoApuestas])>1)){
            moverPosicionApuesta();
            System.out.println("Turno de " +mesa[posicionApuesta].mostrarNombre());
            apostar(mesa[posicionApuesta]);
            // Se comprueba si la apuesta actual supera a la que estaba establecida como la más grande. Si es así se asigna a la apuesta más grande.
            if((Apuestas[numeroGrupoApuestas].tablaApuesta[1][posicionApuesta]) > (Apuestas[numeroGrupoApuestas].tablaApuesta[1][posicionApuestaOriginal]))
                posicionApuestaOriginal = posicionApuesta;
        }
        // Aqui se van resolviendo los grupos de apuestas, decidiendo quienes han dejado de jugar, quienes han hecho all-in, etc...
        // Se van agrupando por grupos para al final de la partida resolver las apuestas por grupo, por ejemplo un jugador que haya hecho
        // All-In con 500 fichas no podrá optar a la apuesta de un jugador que ha puesto 1000 fichas, sólo podrá optar a 500.
        while(GrupoApuesta.resolverGrupoApuestas(Apuestas[numeroGrupoApuestas]) != null){
            Apuestas[numeroGrupoApuestas+1] = new GrupoApuesta(GrupoApuesta.resolverGrupoApuestas(Apuestas[numeroGrupoApuestas]));
            numeroGrupoApuestas++;
        }
    }

    /**
     * Esta es la segunda fase del juego, se ponen tres cartas de la baraja encima de la mesa
     * y los jugadores hacen sus apuestas.
     */
    public static void flop() throws IOException {
        cartasMesa[0] = Carta.repartirCarta();
        cartasMesa[1] = Carta.repartirCarta();
        cartasMesa[2] = Carta.repartirCarta();
        posicionApuesta = posicionApuestaOriginal;
        System.out.println("\n---- FLOP ----");
        cartasMesa[0].muestraCarta();
        cartasMesa[1].muestraCarta();
        cartasMesa[2].muestraCarta();

        // Se realizan las apuestas mientras la comprobacion indique que no se ha terminado
        do{
            Apuestas[numeroGrupoApuestas].actualizarEstados();
            System.out.println("Turno de " +mesa[posicionApuesta].mostrarNombre());
            apostar(mesa[posicionApuesta]);
            // Se comprueba si la apuesta actual supera a la que estaba establecida como la más grande. Si es así se asigna a la apuesta más grande.
            if((Apuestas[numeroGrupoApuestas].tablaApuesta[1][posicionApuesta]) > (Apuestas[numeroGrupoApuestas].tablaApuesta[1][posicionApuestaOriginal]))
                posicionApuestaOriginal = posicionApuesta;
            moverPosicionApuesta();
        }while((Apuestas[numeroGrupoApuestas].comprobarEstados() == false) && (GrupoApuesta.contarJugadores(Apuestas[numeroGrupoApuestas])>1));

        // Aqui se van resolviendo los grupos de apuestas, decidiendo quienes han dejado de jugar, quienes han hecho all-in, etc...
        // Se van agrupando por grupos para al final de la partida resolver las apuestas por grupo, por ejemplo un jugador que haya hecho
        // All-In con 500 fichas no podrá optar a la apuesta de un jugador que ha puesto 1000 fichas, sólo podrá optar a 500.
        while(GrupoApuesta.resolverGrupoApuestas(Apuestas[numeroGrupoApuestas]) != null){
            Apuestas[numeroGrupoApuestas+1] = new GrupoApuesta(GrupoApuesta.resolverGrupoApuestas(Apuestas[numeroGrupoApuestas]));
            numeroGrupoApuestas++;
        }
    }

    /**
     * Esta es la tercera fase del juego, se pone una carta de la baraja encima de la mesa
     * y los jugadores hacen sus apuestas.
     */
    public static void turn() throws IOException {
        cartasMesa[3] = Carta.repartirCarta();

        posicionApuesta = posicionApuestaOriginal;
        System.out.println("\n---- TURN ----");
        cartasMesa[3].muestraCarta();

        // Se realizan las apuestas mientras la comprobacion indique que no se ha terminado
        do{
            Apuestas[numeroGrupoApuestas].actualizarEstados();
            System.out.println("Turno de " +mesa[posicionApuesta].mostrarNombre());
            apostar(mesa[posicionApuesta]);
            // Se comprueba si la apuesta actual supera a la que estaba establecida como la más grande. Si es así se asigna a la apuesta más grande.
            if((Apuestas[numeroGrupoApuestas].tablaApuesta[1][posicionApuesta]) > (Apuestas[numeroGrupoApuestas].tablaApuesta[1][posicionApuestaOriginal]))
                posicionApuestaOriginal = posicionApuesta;
            moverPosicionApuesta();
        }while((Apuestas[numeroGrupoApuestas].comprobarEstados() == false) && (GrupoApuesta.contarJugadores(Apuestas[numeroGrupoApuestas])>1));
        // Aqui se van resolviendo los grupos de apuestas, decidiendo quienes han dejado de jugar, quienes han hecho all-in, etc...
        // Se van agrupando por grupos para al final de la partida resolver las apuestas por grupo, por ejemplo un jugador que haya hecho
        // All-In con 500 fichas no podrá optar a la apuesta de un jugador que ha puesto 1000 fichas, sólo podrá optar a 500.
        while(GrupoApuesta.resolverGrupoApuestas(Apuestas[numeroGrupoApuestas]) != null){
            Apuestas[numeroGrupoApuestas+1] = new GrupoApuesta(GrupoApuesta.resolverGrupoApuestas(Apuestas[numeroGrupoApuestas]));
            numeroGrupoApuestas++;
        }
    }

   /**
     * Esta es la última fase del juego, se pone una carta de la baraja encima de la mesa
     * y los jugadores hacen sus apuestas. Al terminar de apostar
     */
    public static void river() throws IOException {
        cartasMesa[4] = Carta.repartirCarta();

        posicionApuesta = posicionApuestaOriginal;
        System.out.println("\n---- RIVER ----");
        cartasMesa[4].muestraCarta();

        // Se realizan las apuestas mientras la comprobacion indique que no se ha terminado
        do{
            Apuestas[numeroGrupoApuestas].actualizarEstados();
            System.out.println("Turno de " +mesa[posicionApuesta].mostrarNombre());
            apostar(mesa[posicionApuesta]);
            // Se comprueba si la apuesta actual supera a la que estaba establecida como la más grande. Si es así se asigna a la apuesta más grande.
            if((Apuestas[numeroGrupoApuestas].tablaApuesta[1][posicionApuesta]) > (Apuestas[numeroGrupoApuestas].tablaApuesta[1][posicionApuestaOriginal]))
                posicionApuestaOriginal = posicionApuesta;
            moverPosicionApuesta();
        }while((Apuestas[numeroGrupoApuestas].comprobarEstados() == false) && (GrupoApuesta.contarJugadores(Apuestas[numeroGrupoApuestas])>1));
        // Aqui se van resolviendo los grupos de apuestas, decidiendo quienes han dejado de jugar, quienes han hecho all-in, etc...
        // Se van agrupando por grupos para al final de la partida resolver las apuestas por grupo, por ejemplo un jugador que haya hecho
        // All-In con 500 fichas no podrá optar a la apuesta de un jugador que ha puesto 1000 fichas, sólo podrá optar a 500.
        while(GrupoApuesta.resolverGrupoApuestas(Apuestas[numeroGrupoApuestas]) != null){
            Apuestas[numeroGrupoApuestas+1] = new GrupoApuesta(GrupoApuesta.resolverGrupoApuestas(Apuestas[numeroGrupoApuestas]));
            numeroGrupoApuestas++;
        }
    }

    /**
     * Este método evalúa el valor de la jugada del jugador que se le pasa como
     * parámetro. El valor es el siguiente (de menor a mayor):
     * Carta Alta = 0,
     * Pareja = 1,
     * Doble Pareja = 2,
     * Trio = 3,
     * Escalera = 4,
     * Color = 5,
     * Full = 6,
     * Poker = 7,
     * Escalera de color = 8,
     * Escalera real = 9.
     * Se guardará en valor[0] el número correspondiente a la jugada, en valor[1] y valor[2]
     * la carta más alta de la jugada (por ejemplo si es una escalera al 8 pues
     * se guarda el valor del 8) y en valor [3] el valor de la carta más alta de
     * las dos que tenga el jugador (si tiene 8 y As se guardará el valor del As,
     * aunque el 8 haga la escalera).
     * @return
     */
    public static int[] valorMano(Jugador player){
        int[] valor = new int[4];
        Carta[] cartasJugador = new Carta[2];
        Carta[] cartasComunes = new Carta[5];
        Carta[] ordenadas = new Carta[7];
        cartasJugador = player.getCartas();
        cartasComunes = mecanicaJuego.cartasMesa;
        ordenadas = ordenarCartas(cartasJugador, cartasComunes);
        for(int i=0; i<4; i++)
            valor[i] = 0;

        // Compruebo cuál es la carta más alta del jugador y la asigno a la tabla valor
        if(cartasJugador[0].devuelveValor() > cartasJugador[1].devuelveValor())
            valor[3] = cartasJugador[0].devuelveValor();
        else
            valor[3] = cartasJugador[1].devuelveValor();

        // Con varios if anidados voy comprobando si existe alguna jugada, de mayor a menor valor.
        if(escaleraReal(ordenadas)){
            valor[0] = 10;
        }
        else{
            if(escaleraColor(ordenadas)!=-1){
                valor[0] = 9;
                valor[1] = escaleraColor(ordenadas);
            }
            else{
                if(poker(ordenadas)!=-1){
                    valor[0] = 8;
                    valor[1] = poker(ordenadas);
                }
                else{
                    if(pareja_full_trio(ordenadas)[0]==4){
                        valor[0] = 7;
                        valor[1] = pareja_full_trio(ordenadas)[1];
                        valor[2] = pareja_full_trio(ordenadas)[2];
                    }
                    else{
                        if(color(ordenadas)!=-1){
                            valor[0] = 6;
                            valor[1] = color(ordenadas);
                        }
                        else{
                            if(escaleraSimple(ordenadas)!=-1){
                                valor[0] = 5;
                                valor[1] = escaleraSimple(ordenadas);
                            }
                            else{
                                if(pareja_full_trio(ordenadas)[0]==3){
                                    valor[0] = 4;
                                    valor[1] = pareja_full_trio(ordenadas)[1];
                                }
                                else{
                                    if(pareja_full_trio(ordenadas)[0]==2){
                                        valor[0] = 3;
                                        valor[1] = pareja_full_trio(ordenadas)[1];
                                        valor[2] = pareja_full_trio(ordenadas)[2];
                                    }
                                    else{
                                        if(pareja_full_trio(ordenadas)[0]==1){
                                            valor[0] = 2;
                                            valor[1] = pareja_full_trio(ordenadas)[1];
                                        }
                                        else{
                                            valor[0] = 1;
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }




        return valor;
    }

    /**
     * Este método ordena las cartas de mayor a menor.
     * @param cartasJugador Las dos cartas del jugador
     * @param cartasComunes Las 5 cartas que hay en la mesa.
     * @return Las 7 cartas ordenadas de menor a mayor.
     */
    public static Carta[] ordenarCartas(Carta[] cartasJugador, Carta[] cartasComunes){
        Carta[] cartasOrdenadas = new Carta[7];
        for(int i=0; i<7; i++){
            if(i<2)
                cartasOrdenadas[i] = cartasJugador[i];
            else
                cartasOrdenadas[i] = cartasComunes[i-2];
        }
        Carta buffer;

        for(int i=0; i<7; i++) {
            for(int j=0; j<i; j++) {
                if(cartasOrdenadas[i].devuelveValor() > cartasOrdenadas[j].devuelveValor()) {
                    buffer = cartasOrdenadas[j];
                    cartasOrdenadas[j] = cartasOrdenadas[i];
                    cartasOrdenadas[i] = buffer;
                }
            }
        }
        return cartasOrdenadas;
    }

    /**
     * Este método comprueba si hay una escalera real.
     * @param cartas
     * @return Devuelve true si hay escalera real y false si no la hay.
     */
    public static boolean escaleraReal(Carta[] cartas){
        boolean escaleraReal = false;
        int numeroCartasEscalera = 1;
        int contadorCartas = 0;
        int palo;
        
        while(contadorCartas<3 && escaleraReal == false) {
            numeroCartasEscalera = 1;
            if(cartas[contadorCartas].devuelveValor()==14){
                int i = contadorCartas+1;
                while(i<7 && numeroCartasEscalera<5) {
                    if(((cartas[i].devuelvePalo())==(cartas[contadorCartas].devuelvePalo())) && ((14 - (cartas[i].devuelveValor())) == numeroCartasEscalera)){
                        numeroCartasEscalera++;
                    }
                    i++;
                }
                if(numeroCartasEscalera == 5)
                    escaleraReal = true;
            }
            contadorCartas++;
        }
        return escaleraReal;
    }

    /**
     * Este método comprueba si hay poker (cuatro cartas del mismo número).
     * @param cartas
     * @return El número de la carta que forma el póker y si no hay póker devuelve -1.
     */
    public static int poker(Carta[] cartas){
        int valorPoker = 0;
        int numeroCartasPoker = 1;
        int contador = 0;
        while(numeroCartasPoker<4 && contador<4){
            numeroCartasPoker = 1;
            valorPoker = cartas[contador].devuelveValor();
            int i = contador+1;
            while(i<7 && numeroCartasPoker<4){
                if(cartas[i].devuelveValor()==valorPoker)
                    numeroCartasPoker++;
                i++;
            }
            contador++;
        }
        if(numeroCartasPoker==4)
            return valorPoker;
        else
            return -1;
    }

    /**
     * Este método comprueba si hay escalera (5 cartas con valores consecutivos).
     * @param cartas
     * @return Devuelve el valor de la carta más alta de la escalera si la hay y
     * no devuelve -1.
     */
    public static int escaleraSimple(Carta[] cartas){
        int numeroCartasEscalera = 1;
        int contadorCartas = 0;
        boolean escalera = false;
        int valorEscalera = 0;

        while(contadorCartas<3 && escalera == false) {
            valorEscalera = cartas[contadorCartas].devuelveValor();
            numeroCartasEscalera = 1;
            int i = contadorCartas+1;
            while(i<7 && numeroCartasEscalera<5) {
                if(((cartas[contadorCartas].devuelveValor()) - (cartas[i].devuelveValor())) == numeroCartasEscalera){
                    numeroCartasEscalera++;
                }
                i++;
            }
            if(numeroCartasEscalera == 5)
                escalera = true;
            contadorCartas++;
        }
        if(escalera == true)
            return valorEscalera;
        else
            return -1;
    }

    /**
     * Este método comprueba si hay escalera de color (5 cartas con valores consecutivos del mismo palo).
     * @param cartas
     * @return Devuelve el valor de la carta más alta de la escalera si la hay y
     * no devuelve -1.
     */
    public static int escaleraColor(Carta[] cartas){
        int numeroCartasEscalera = 1;
        int contadorCartas = 0;
        boolean escalera = false;
        int valorEscalera = 0;

        while(contadorCartas<3 && escalera == false) {
            valorEscalera = cartas[contadorCartas].devuelveValor();
            numeroCartasEscalera = 1;
            int i = contadorCartas+1;
            while(i<7 && numeroCartasEscalera<5) {
                if(((cartas[i].devuelvePalo())==(cartas[contadorCartas].devuelvePalo())) && ((cartas[contadorCartas].devuelveValor()) - (cartas[i].devuelveValor())) == numeroCartasEscalera){
                    numeroCartasEscalera++;
                }
                i++;
            }
            if(numeroCartasEscalera == 5)
                escalera = true;
            contadorCartas++;
        }
        if(escalera == true)
            return valorEscalera;
        else
            return -1;
    }

    /**
     * Este método se encarga de comprobar si hay full, trio, pareja, doble pareja o nada.
     * @param cartas
     * @return En el campo devuelto[0] introduce el tipo de jugada que hay:
     * Si hay pareja devuelve 1, si hay doble pareja devuelve 2, si hay trio devuelve 3 y si hay full devuelve 4.
     * En caso de que no haya ninguna jugada devuelve 0.
     * En el campo devuelto[1] devuelve según el caso: {pareja}: el valor de la carta que forma la pareja;
     * {doble pareja}: el valor de la carta que forma la pareja más alta;
     * {trio}: el valor de la carta que forma el trío;
     * {full}: el valor de la carta que forma el trío;
     * {carta alta}: el valor de la carta más alta de la mano;
     * En el campo devuelto[2] devuelve según el caso:
     * {doble pareja}: el valor de la carta que forma la pareja más baja;
     * {full}: el valor de la carta que forma la pareja;
     */
    public static int[] pareja_full_trio(Carta[] cartas){

        int valorTrio = 0;
        boolean hayTrio = false;
        int valorPareja1 = 0;
        boolean hayPareja1 = false;
        int valorPareja2 = 0;
        boolean hayPareja2 = false;
        int[] devuelto = new int [3];
        int contadorCarta = 0;
        int contadorJugada = 1;
        while(contadorCarta<6){
            contadorJugada = 1;
            if(cartas[contadorCarta].devuelveValor() != valorPareja1 && cartas[contadorCarta].devuelveValor() != valorPareja2 && cartas[contadorCarta].devuelveValor() != valorTrio){
                for(int i=contadorCarta+1; i<7; i++){
                    if(cartas[contadorCarta].devuelveValor() == cartas[i].devuelveValor())
                        contadorJugada++;
                }

                switch(contadorJugada) {
                    case 3:
                        if(hayTrio){
                            if(cartas[contadorCarta].devuelveValor()>valorTrio){
                                valorPareja1 = valorTrio;
                                hayPareja1 = true;
                                valorTrio = cartas[contadorCarta].devuelveValor();
                            }
                            else{
                                hayPareja1 = true;
                                valorPareja1 = cartas[contadorCarta].devuelveValor();
                            }
                        }
                        else{
                            hayTrio = true;
                            valorTrio = cartas[contadorCarta].devuelveValor();
                        }
                        break;
                    case 2:
                        if(hayPareja1){
                            if(hayPareja2){
                                if(cartas[contadorCarta].devuelveValor() > valorPareja2)
                                    valorPareja2 = cartas[contadorCarta].devuelveValor();
                            }
                            else{
                                hayPareja2 = true;
                            }
                        }
                        else{
                            hayPareja1 = true;
                            valorPareja1 = cartas[contadorCarta].devuelveValor();
                        }
                        break;
                }
            }
            contadorCarta++;
        }
        if(hayTrio){
            if(hayPareja1){
                devuelto[0] = 4;
                devuelto[1] = valorTrio;
                devuelto[2] = valorPareja1;
            }
            else{
                devuelto[0] = 3;
                devuelto[1] = valorTrio;
            }
        }
        else{
            if(hayPareja2){
                devuelto[0] = 2;
                devuelto[1] = valorPareja1;
                devuelto[2] = valorPareja2;
            }
            else{
                if(hayPareja1){
                    devuelto[0] = 1;
                    devuelto[1] = valorPareja1;
                }
                else{
                    devuelto[0] = 0;
                    devuelto[1] = cartas[contadorCarta].devuelveValor();
                }
            }
        }
        return devuelto;
    }

    /**
     * Este método comprueba si hay color (5 cartas del mismo palo).
     * @param cartas
     * @return Devuelve el valor de la carta más alta del color o -1 si no hay color.
     */
    public static int color(Carta[] cartas){
        int valorColor = 0;
        int contadorColor = 0;
        int palo = 1;

        while(palo<5 && contadorColor<5){
            contadorColor = 0;
            valorColor = -1;
            for(int i=0; i<7; i++){
                if(cartas[i].devuelvePalo() == palo){
                    contadorColor++;
                    if(cartas[i].devuelveValor() > valorColor)
                        valorColor = cartas[i].devuelveValor();
                }
            }
            if(contadorColor < 5){
                palo++;
                valorColor = -1;
            }
        }
        return valorColor;
    }

    public static void repartirPremios(){
        while(numeroGrupoApuestas >=0){
            repartirGrupoApuesta(Apuestas[numeroGrupoApuestas]);
            numeroGrupoApuestas--;
        }
    }

    /**
     * En tablaGanadores se almacenan los ganadores del grupoApuesta.
     * @param apuestas
     */
    public static void repartirGrupoApuesta(GrupoApuesta apuestas){
        int[] jugadaGanadora = new int[4];
        int[] jugadaActual = new int[4];
        int numeroGanadores = 0;
        int bote = 0;
        int[] tablaGanadores = new int[9];
        boolean salirBucle = false;
        int contJugada = 0;

        for(int i=0; i<9; i++){
            bote = bote+apuestas.tablaApuesta[1][i];
            tablaGanadores[i]=0;
        }

        for(int i=0; i<9; i++){
            if(apuestas.tablaApuesta[0][i]!=0){
                jugadaActual = valorMano(mesa[i]);
                if(numeroGanadores==0){
                   tablaGanadores[numeroGanadores] = i;
                   numeroGanadores ++;
                   jugadaGanadora = jugadaActual;
                }
                else{
                    salirBucle = false;
                    contJugada = 0;
                    while(salirBucle==false && contJugada<4){
                        if(jugadaGanadora[contJugada] < jugadaActual[contJugada]){
                            tablaGanadores[0] = i;
                            numeroGanadores = 1;
                            jugadaGanadora = jugadaActual;
                        }
                        else{
                            if(jugadaGanadora[contJugada] > jugadaActual[contJugada])
                                salirBucle = true;
                            else{
                                if(contJugada==3){
                                    tablaGanadores[numeroGanadores] = i;
                                    numeroGanadores ++;
                                }
                            }
                        }
                        contJugada++;
                    }
                }
            }
        }

        bote = bote / numeroGanadores;
        for(int i=0; i<numeroGanadores; i++){
            mesa[tablaGanadores[i]].cobrarFichas(bote / numeroGanadores);
        }
    }
}
